package delphorm.web.controller;


import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Iterator;

import javax.servlet.http.HttpServletRequest;

import net.sf.cglib.beans.BeanGenerator;

import org.springframework.beans.propertyeditors.CustomNumberEditor;
import org.springframework.validation.BindException;
import org.springframework.web.bind.ServletRequestDataBinder;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.multipart.support.ByteArrayMultipartFileEditor;

import delphorm.entite.personne.Utilisateur;
import delphorm.entite.questionnaire.FiltreNumerique;
import delphorm.entite.questionnaire.FiltreTexte;
import delphorm.entite.questionnaire.InstanceQuestion;
import delphorm.entite.questionnaire.InstanceQuestionnaire;
import delphorm.entite.questionnaire.InstanceReponseFermee;
import delphorm.entite.questionnaire.InstanceReponseOuverte;
import delphorm.entite.questionnaire.Question;
import delphorm.entite.questionnaire.Questionnaire;
import delphorm.entite.questionnaire.Reponse;
import delphorm.entite.questionnaire.ReponseOuverte;
import delphorm.entite.questionnaire.ValeurFichier;
import delphorm.entite.questionnaire.ValeurNumerique;
import delphorm.entite.questionnaire.ValeurTexte;
import delphorm.service.questionnaire.IQuestionnaire;
import delphorm.web.taglibs.Toolz;

/*import delphorm.web.forms.NamingFormulaireInstanceQuestionnaire;*/


public class SaisirInstanceQuestionnaire extends org.springframework.web.servlet.mvc.SimpleFormController {
	
	protected IQuestionnaire serviceQuestionnaire;
	
	//questionnaire qui correspond à l'instance
	protected Questionnaire questionnaire;
	
	//utilisateur qui remplit le questionnaire
	private Utilisateur auteur;
	
	
	public Utilisateur getAuteur() {
		return auteur;
	}

	public void setAuteur(Utilisateur auteur) {
		this.auteur = auteur;
	}

	public Questionnaire getQuestionnaire() {
		return questionnaire;
	}

	public void setQuestionnaire(Questionnaire questionnaire) {
		this.questionnaire = questionnaire;
	}

	public IQuestionnaire getServiceQuestionnaire() {
		return serviceQuestionnaire;
	}

	public void setServiceQuestionnaire(IQuestionnaire serviceQuestionnaire) {
		this.serviceQuestionnaire = serviceQuestionnaire;
	}

	/*protected ModelAndView showForm(HttpServletRequest request, HttpServletResponse responses, BindException errors) throws Exception {
		Map model = new HashMap();
		model.put(this.getCommandName(),this.formBackingObject(request));
		return new ModelAndView("saisirInstanceQuestionnaire",model);
	}

	protected ModelAndView processFormSubmission(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, BindException arg3) throws Exception {
		return new ModelAndView("index");
	}*/

	protected Object formBackingObject(HttpServletRequest request) throws Exception {
		//		récupère le formulaire dans la session
		Object formulaire = request.getSession().getAttribute("formulaire");
		
		if(formulaire == null)
		{
			//récupere le questionnaire
			String numQuestionnaire = request.getParameter("numeroquestionnaire");
			//TODO exception si null
			Long numero = Long.parseLong(numQuestionnaire);
			//TODO exception si erreur conversion
			Questionnaire questionnaire = serviceQuestionnaire.getQuestionnaireParId(new Long(numero));
			//TODO exception si null 
			//TODO vérifier que le questionnaire a le droit d'être rempli
			request.getSession().setAttribute("questionnaire",questionnaire); //permet d'être utilisé par la JSP
			
			//fixe le questionnaire
			setQuestionnaire(questionnaire);
			
			//récupère l'utilisateur 
			Utilisateur auteur = (Utilisateur)request.getSession().getAttribute("utilisateur");
			//pas besoin de vérification: l'intercepteur a deja fait ce boulot
			this.setAuteur(auteur);
			
			//génere le bean de formulaire
			formulaire = genererFormulaireFromQuestionnaire(questionnaire);
		}
		//TODO commentaires trash
		Method[] methods = formulaire.getClass().getDeclaredMethods();
		for(int i=0;i<methods.length;i++)
			System.out.println(((Method)methods[i]).getName());
		
		return formulaire;
	}

	protected Object genererFormulaireFromQuestionnaire(Questionnaire questionnaire) {
		BeanGenerator bg = new BeanGenerator();
		//bg.setNamingPolicy(new NamingFormulaireInstanceQuestionnaire());
		bg.setSuperclass(Object.class);
		Iterator itQuestions = questionnaire.getQuestions().iterator();
		
		//l'etat
		bg.addProperty("etat",Character.class);
		
		//pour chaque question
		while(itQuestions.hasNext())
		{
			Question question = (Question)itQuestions.next();
			//si la question n'a qu'une et une seule réponse possible, 
			//il n'y a qu'une propriété pour toutes les réponses
			if(Toolz.getTypeControl(question).equals("radio"))
			{
				String nomPropriete = "radio_reponse_question_"+question.getPlace();
				bg.addProperty(nomPropriete,Integer.class);
			}
			Iterator itReponses = question.getReponses().iterator();
			//pour chaque réponse
			while(itReponses.hasNext())
			{				
				Reponse reponse = (Reponse)itReponses.next();
				//cas de reponse numerotee
				if(Toolz.getTypeControl(question,reponse).equals("liste"))
				{
					String nomPropriete = "place_reponse_question_"+question.getPlace()+"_"+reponse.getCode();
					bg.addProperty(nomPropriete,Integer.class);
				}
			
				else if(Toolz.getTypeControl(question).equals("checkbox"))
				{
					String nomPropriete = "checkbox_reponse_question_"+question.getPlace()+"_"+reponse.getCode();
					bg.addProperty(nomPropriete,Integer.class);
				}
				//TODO else exception
				if(reponse.getType().equals("ouverte"))
				{
					if(reponse.getTypeDeDonnees().equals(new Character('N')))
					{
						String nomPropriete = "reponseouvertenumerique_question_"+question.getPlace()+"_"+reponse.getCode();
						bg.addProperty(nomPropriete,Double.class);
					}
					else if(reponse.getTypeDeDonnees().equals(new Character('T')))
					{
						String nomPropriete = "reponseouvertetexte_question_"+question.getPlace()+"_"+reponse.getCode();
						bg.addProperty(nomPropriete,String.class);
					}
					else if(reponse.getTypeDeDonnees().equals(new Character('F')))
					{
						String nomPropriete = "reponseouvertefichier_question_"+question.getPlace()+"_"+reponse.getCode();
						bg.addProperty(nomPropriete,byte[].class);
						nomPropriete = "reponseouvertenomfichier_question_"+question.getPlace()+"_"+reponse.getCode();
						bg.addProperty(nomPropriete,String.class);
						nomPropriete = "reponseouvertefilename_question_"+question.getPlace()+"_"+reponse.getCode();
						bg.addProperty(nomPropriete,String.class);
						
					}
					//TODO else exception
				}
			}	
			
		}
		
		return bg.create();
	}
	protected void onBindAndValidate(HttpServletRequest request, Object formulaire, BindException errors) throws Exception {
		String nomMethod = "getEtat";
		Method method = formulaire.getClass().getMethod(nomMethod,null);
		Character resultat = (Character)method.invoke(formulaire,null);
		if(resultat.charValue() == 'O')
			onBindAndValidateCoherent(request,formulaire,errors);
	}
	protected void onBindAndValidateCoherent(HttpServletRequest request, Object formulaire, BindException errors) throws Exception {
		
//		récupère le questionnaire 
		Questionnaire questionnaire = getQuestionnaire();
		
		Iterator itQuestions = questionnaire.getQuestions().iterator();
		
		//pour chaque question
		while(itQuestions.hasNext())
		{
			Question question = (Question)itQuestions.next();
			
			//si la question n'a qu'une et une seule réponse possible, 
			//il n'y a qu'une propriété pour toutes les réponses
			if(Toolz.getTypeControl(question).equals("radio"))
			{
				String nomMethod = "getRadio_reponse_question_"+question.getPlace();
				Method method = formulaire.getClass().getMethod(nomMethod,null);
				Integer resultat = (Integer)method.invoke(formulaire,null);
				if(resultat == null) //si rien n'est coché
				{
					Object[] param = {question.getPlace()};
					errors.reject("instancequestionnaire.question.uneetuneseulereponse",param,null);	
				}
				else
				{
					//récupère la réponse
					Reponse reponse = question.getReponse(resultat);
					//vérifier le filtre de la réponse
					verifierFiltreReponse(question, reponse, formulaire, errors);
					//vérifier les erreurs de convertions car il n'est pas possible de créer un message personnalisé
					//puisqiue les champs du formulaire sont tout le temps différents
					//TODO essayer avec un Loader de message dynañique pour personnaliser les erreurs
					//problèmes de performaxnce??
				}
				
			}
			
			
			//vérifier question ordonnée
			else if(Toolz.getTypeControl(question,null).equals("liste"))
			{
				Iterator itReponses = question.getReponses().iterator();
				//sert a compter le nombre de reponses numerotees
				int cptNombreNumerote = 0;
				//tableau qui permet de connaitre quelle reponse a quelle position
				Reponse[] tabPlaces = new Reponse[question.getMaxReponses().intValue()];
				
				while(itReponses.hasNext())
				{
					Reponse reponse = (Reponse)itReponses.next();
					
					String nomMethod = "getPlace_reponse_question_"+question.getPlace()+"_"+reponse.getCode();
					Method method = formulaire.getClass().getMethod(nomMethod,null);
					Integer position = (Integer)method.invoke(formulaire,null);
					//si la réponse est sélectionnée
					if(position != null && position.intValue() != -1)
					{
//						vérifie qu'une autre réponse n'a pas le même code
						if(tabPlaces[position.intValue()-1] == null)
						{
							tabPlaces[position.intValue()-1] = reponse;
							cptNombreNumerote++;
						}
						else
						{
							Object[] param = {question.getPlace(),reponse.getCode(),position,tabPlaces[position.intValue()-1].getCode()};
							errors.reject("instancequestionnaire.question.numerotee.doublon",param,null);	
						}	
						//vérifie le filtre de lq réponse
						verifierFiltreReponse(question, reponse, formulaire, errors);
					}
				}
				//vérifie qu'il y a assez de réponse numérotées
				if(question.getMinReponses().intValue()>cptNombreNumerote)
				{
					Object[] param = {question.getPlace(),new Integer(cptNombreNumerote),question.getMinReponses()};
					for(int index=0;index<param.length;index++)
						System.out.println(param[index]);
					errors.reject("instancequestionnaire.question.numerotee.pasassez",param,"pas assez de réponse numérotées");
					//errors.reject("enregistrerQuestionnaire.question.pasassezreponses",param,"pas assez de réponse numérotées");
				}
				
//				vérifie qu'il n'y a pas trop de réponse numérotées
				else if(question.getMaxReponses().intValue()<cptNombreNumerote)
				{
					Object[] param = {question.getPlace(),new Integer(cptNombreNumerote),question.getMaxReponses()};
					errors.reject("instancequestionnaire.question.numerotee.trop",param,null);	
				}
				
				//vérifie que les numéros sont séquentiels
				for(int index = 0; index < cptNombreNumerote; index++)
				{
					if(tabPlaces[index] == null)
					{
						Object[] param = {question.getPlace()};
						errors.reject("instancequestionnaire.question.numerotee.passequentiel",param,null);	
						break;
					}
				}
			}
			
			
			//traiter questions cochées
			else if(Toolz.getTypeControl(question).equals("checkbox"))
			{
//				sert a compter le nombre de reponses cochees
				int cptNombreCoche = 0;
				
				Iterator itReponses = question.getReponses().iterator();
				while(itReponses.hasNext())
				{
					Reponse reponse = (Reponse)itReponses.next();
					String nomMethod = "getCheckbox_reponse_question_"+question.getPlace()+"_"+reponse.getCode();
					Method method = formulaire.getClass().getMethod(nomMethod,null);
					Integer numero = (Integer)method.invoke(formulaire,null);
					
					//si la réponse est sélectionnée
					if(numero != null)
					{
						cptNombreCoche++;
//						vérifie le filtre de lq réponse
						verifierFiltreReponse(question, reponse, formulaire, errors);
					}
				}
				if(question.getMinReponses().intValue() > cptNombreCoche)
				{
					Object[] param = {question.getPlace(),new Integer(cptNombreCoche),question.getMinReponses()};
					errors.reject("instancequestionnaire.question.cochee.pasassez",param,null);	
				}
				else if(question.getMaxReponses().intValue() < cptNombreCoche)
				{
					Object[] param = {question.getPlace(),new Integer(cptNombreCoche),question.getMaxReponses()};
					errors.reject("instancequestionnaire.question.cochee.trop",param,null);	
				}
			}		
		}
	}
	
/*	private void verifierErreursDeConversion(Question question, Reponse reponse, BindException errors) {
		//on ne vérifie que les réponses ouvertes numériques
		if(reponse.getType().equals(new String("ouverte")))
		{
			
			if(reponse.getTypeDeDonnees().equals(new Character('N')))
			{
				List fieldErrors = errors.getFieldErrors("reponseouvertenumerique_question_"+question.getPlace()+"_"+reponse.getCode());
				Iterator it = fieldErrors.iterator();
				while(it.hasNext())
				{
					FieldError fieldError = (FieldError)it.next();
					if(fieldError.isBindingFailure())
					{
						//supprime l'erreur
						fieldErrors.remove(fieldError);
						//et remplace
						errors.rejectValue("reponseouvertenumerique_question_"+question.getPlace()+"_"+reponse.getCode(),"instancequestionnaire.reponseouvertenumerique.pasunnombre");
					}
				}
			}
		}
		
	}*/

	private void verifierFiltreReponse(Question question, Reponse reponse, Object formulaire, BindException errors) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {
		if(reponse.getType().equals(new String("ouverte")))
		{
			ReponseOuverte reponseOuverte =(ReponseOuverte)reponse;
			if(reponseOuverte.getFiltre() != null)
			{
				if(reponse.getTypeDeDonnees().equals(new Character('N')))
				{
					FiltreNumerique filtreNumerique = (FiltreNumerique)reponseOuverte.getFiltre();
					
					String nomMethod = "getReponseouvertenumerique_question_"+question.getPlace()+"_"+reponse.getCode();
					Method method = formulaire.getClass().getMethod(nomMethod,null);
					Double formVal = (Double)method.invoke(formulaire,null);
					
					ValeurNumerique valeur = new ValeurNumerique();
					valeur.setValeur((Double)formVal);
					
					if(!filtreNumerique.Check(valeur))
					{
						Object[] param = {question.getPlace(),reponse.getCode()};
						errors.rejectValue("reponseouvertenumerique_question_"+question.getPlace()+"_"+reponse.getCode(),"instancequestionnaire.filtrenumerique.mauvais",param,null);
					}
				}
				else if(reponse.getTypeDeDonnees().equals(new Character('T')))
				{
					FiltreTexte filtreTexte = (FiltreTexte)reponseOuverte.getFiltre();
					
					String nomMethod = "getReponseouvertetexte_question_"+question.getPlace()+"_"+reponse.getCode();
					Method method = formulaire.getClass().getMethod(nomMethod,null);
					String formVal = (String)method.invoke(formulaire,null);
					
					ValeurTexte valeur = new ValeurTexte();
					valeur.setValeur((String)formVal);
					
					if(!filtreTexte.Check(valeur))
					{
						Object[] param = {question.getPlace(),reponse.getCode()};
						errors.rejectValue("reponseouvertetexte_question_"+question.getPlace()+"_"+reponse.getCode(),"instancequestionnaire.filtretexte.mauvais",param,null);
					}
				}
				//TODO else exception
			}
		}
		
	}



	protected void initBinder(HttpServletRequest req, ServletRequestDataBinder binder) throws Exception {
		// TODO Auto-generated method stub
		super.initBinder(req, binder);
		binder.registerCustomEditor(Double.class,new CustomNumberEditor(Double.class,true));
		binder.registerCustomEditor(byte[].class, new ByteArrayMultipartFileEditor());
	}
	
	protected InstanceQuestionnaire getInstanceQuestionnaireFromFormulaire(Object formulaire, Questionnaire questionnaire, Utilisateur auteur) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException
	{
		//récupère une nouvelle instance de questionnaire initialié (questionnaire,auteur,date)
		InstanceQuestionnaire instanceQuestionnaire = serviceQuestionnaire.nouveauInstanceQuestionnaire(questionnaire,auteur);
		
		//récupère l'état
		String nomMethod = "getEtat";
		Method method = formulaire.getClass().getMethod(nomMethod,null);
		Character resultatEtat = (Character)method.invoke(formulaire,null);
		instanceQuestionnaire.setEtat(resultatEtat);
		
		//pour chaque question
		Iterator itQuestion = questionnaire.getQuestions().iterator();
		while(itQuestion.hasNext())
		{
			Question question = (Question)itQuestion.next();
			//crée une instance de question
			InstanceQuestion instanceQuestion = new InstanceQuestion();
			//fixe la question
			instanceQuestion.setQuestion(question);
			//ajoute la instance question a l'instance questionnaire
			instanceQuestionnaire.getInstancesQuestion().add(instanceQuestion);
			//pour chaque réponse
			Iterator itReponse = question.getReponses().iterator();
			while(itReponse.hasNext())
			{
				Reponse reponse = (Reponse)itReponse.next();
				//cré l'instance de réponse
				
				//cette variable sert à détermuiner si une réponse a été sélectionnée
				//(on n'enregistre que les réponses sélectionnées)
				boolean reponseSelectionnee = false;
				
				//cette variable sert à enregistrer la position de la réponse dans le cas d'une question numérotée
				Integer position = null;
				
//				si la question n'a qu'une et une seule réponse possible, 
				//il n'y a qu'une propriété pour toutes les réponses
				if(Toolz.getTypeControl(question).equals("radio"))
				{
					nomMethod = "getRadio_reponse_question_"+question.getPlace();
					method = formulaire.getClass().getMethod(nomMethod,null);
					Integer resultat = (Integer)method.invoke(formulaire,null);
					if(resultat.equals(reponse.getCode()))
					{
						reponseSelectionnee = true;	
					}
				}
				
//				cas de reponse numerotee
				//on récupère le numéro d'ordre
				else if(Toolz.getTypeControl(question,reponse).equals("liste"))
				{
					nomMethod = "getPlace_reponse_question_"+question.getPlace()+"_"+reponse.getCode();
					method = formulaire.getClass().getMethod(nomMethod,null);
					Integer pos = (Integer)method.invoke(formulaire,null);
					if(pos != null && pos.intValue() != -1)
					{
						position = pos;
						reponseSelectionnee = true;
					}
				}
			
				else if(Toolz.getTypeControl(question).equals("checkbox"))
				{
					nomMethod = "getCheckbox_reponse_question_"+question.getPlace()+"_"+reponse.getCode();
					method = formulaire.getClass().getMethod(nomMethod,null);
					Integer numero = (Integer)method.invoke(formulaire,null);
					if(numero != null)
					{
						reponseSelectionnee = true;
					}
				}
				//TODO else exception
				
				//si la réponse a été sélectionnée, on ajoute l'instance de réponse à l'instance de question
				if(reponseSelectionnee==true)
				{
					//si la reponse est ouverte
					if(reponse.getType().equals("ouverte"))
					{
						//crée l'instance de reponse avec son lien au métamodèle, fixe le numéro
						InstanceReponseOuverte instanceReponseOuverte = new InstanceReponseOuverte();
						instanceReponseOuverte.setReponse(reponse);
						instanceReponseOuverte.setNumeroOrdre(position);
						
						if(reponse.getTypeDeDonnees().equals(new Character('N')))
						{
							//exécute la méthode
							nomMethod = "getReponseouvertenumerique_question_"+question.getPlace()+"_"+reponse.getCode();
							method = formulaire.getClass().getMethod(nomMethod,null);
							Double formValeur = (Double)method.invoke(formulaire,null);
							
							//crée et fixe la valeur
							ValeurNumerique valeur = new ValeurNumerique();
							valeur.setValeur(formValeur);
							instanceReponseOuverte.setValeur(valeur);
					
						}
						else if(reponse.getTypeDeDonnees().equals(new Character('T')))
						{
	//						exécute la méthode
							nomMethod = "getReponseouvertetexte_question_"+question.getPlace()+"_"+reponse.getCode();
							method = formulaire.getClass().getMethod(nomMethod,null);
							String formValeur = (String)method.invoke(formulaire,null);
							
							//crée et fixe la valeur
							ValeurTexte valeur = new ValeurTexte();
							valeur.setValeur(formValeur);
							instanceReponseOuverte.setValeur(valeur);
							
						}
						else if(reponse.getTypeDeDonnees().equals(new Character('F')))
						{
	//						exécute la méthode
							nomMethod = "getReponseouvertefichier_question_"+question.getPlace()+"_"+reponse.getCode();
							method = formulaire.getClass().getMethod(nomMethod,null);
							byte[] formValeurFichier = (byte[])method.invoke(formulaire,null);
							
							nomMethod = "getReponseouvertenomfichier_question_"+question.getPlace()+"_"+reponse.getCode();
							method = formulaire.getClass().getMethod(nomMethod,null);
							String formValeurNomFichier = (String)method.invoke(formulaire,null);
							
							nomMethod = "getReponseouvertefilename_question_"+question.getPlace()+"_"+reponse.getCode();
							method = formulaire.getClass().getMethod(nomMethod,null);
							String formValeurFilename = (String)method.invoke(formulaire,null);
							
							//crée et fixe la valeur
							ValeurFichier valeur = new ValeurFichier();
							valeur.setFichier(formValeurFichier);
							valeur.setFilename(formValeurFilename);
							valeur.setNomFichier(formValeurNomFichier);
							instanceReponseOuverte.setValeur(valeur);
							
						}
						//TODO else exception
						
	//					ajoute l'instance de réponse à l'instance de question 
						instanceQuestion.getInstancesReponse().add(instanceReponseOuverte);
						
					}
					else if(reponse.getType().equals("fermee"))
					{
	//					crée l'instance de reponse avec son lien au métamodèle, fixe le numéro
						InstanceReponseFermee instanceReponseFermee = new InstanceReponseFermee();
						instanceReponseFermee.setReponse(reponse);
						instanceReponseFermee.setNumeroOrdre(position);
						
	//					ajoute l'instance de réponse à l'instance de question 
						instanceQuestion.getInstancesReponse().add(instanceReponseFermee);		
					}
	//				TODO else exception
				}//fin if selectionnee
			}//fin while reponse
		}//fin while question
		return instanceQuestionnaire;
	}

	protected void doSubmitAction(Object formulaire) throws Exception {
		InstanceQuestionnaire instanceQuestionnaire = this.getInstanceQuestionnaireFromFormulaire(formulaire,getQuestionnaire(),getAuteur());
		if(instanceQuestionnaire.getEtat().charValue() == 'O')
			serviceQuestionnaire.enregistrerInstanceQuestionnaire(instanceQuestionnaire);
		else if(instanceQuestionnaire.getEtat().charValue() == 'C')
			serviceQuestionnaire.enregistrerInstanceQuestionnairePartiel(instanceQuestionnaire);		
	}

	protected void onBind(HttpServletRequest request, Object formulaire, BindException errors) throws Exception {
		// TODO Auto-generated method stub
		super.onBind(request, formulaire, errors);
		MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
		Method[] methods = formulaire.getClass().getMethods();
		for(int i=0; i<methods.length; i++)
		{
			String nomMethod = methods[i].getName();
			if(nomMethod.matches("getReponseouvertefichier.+"))
			{
				String nomPropriete ="r"+nomMethod.substring(4);
//				Récupère le nom du fichier			
//				 on récupère une référence sur le fichier chargé
				MultipartFile fichier = multipartRequest.getFile(nomPropriete);
				String filename = fichier.getOriginalFilename();
				if(!filename.equals(""))
				{
					String nomMethodSetFilename = "setReponseouvertefilename"+nomMethod.substring(24);
					Class[] params = {filename.getClass()};
					Method method = formulaire.getClass().getMethod(nomMethodSetFilename,params);
					Object[] args = {filename};
					method.invoke(formulaire,args);
				}
			}
		}
	}
	
	
	/*//méthode qui vérifie les filtres des réponses ouvertes.
	private void verifierFiltres(Object formulaire, BindException errors) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {
		
		Iterator itQuestions = getQuestionnaire().getQuestions().iterator();
		
		//pour chaque question
		while(itQuestions.hasNext())
		{
			Question question = (Question)itQuestions.next();
			
			Iterator itReponses = question.getReponses().iterator();
			//pour chaque réponse
			while(itReponses.hasNext())
			{				
				Reponse reponse = (Reponse)itReponses.next();
				
				//TODO else exception
				if(reponse.getType().equals("ouverte"))
				{
					ReponseOuverte reponseOuverte =(ReponseOuverte)reponse;
					if(reponseOuverte.getFiltre() != null)
					{
						if(reponse.getTypeDeDonnees().equals(new Character('N')))
						{
							FiltreNumerique filtreNumerique = (FiltreNumerique)reponseOuverte.getFiltre();
							
							String nomMethode = "getReponseouvertenumerique_question_"+question.getPlace()+"_"+reponse.getCode();
							Method method = formulaire.getClass().getMethod(nomMethode,null);
							Double formValeur = (Double)method.invoke(formulaire,null);
							
							ValeurNumerique valeur = new ValeurNumerique();
							valeur.setValeur(formValeur);
							
							if(!filtreNumerique.Check(valeur))
							{
								Object[] param = {question.getPlace(),reponse.getCode()};
								errors.rejectValue("reponseouvertenumerique_question_"+question.getPlace()+"_"+reponse.getCode(),"instancequestionnaire.filtrenumerique.mauvais",param,null);
							}
						}
						else if(reponse.getTypeDeDonnees().equals(new Character('T')))
						{
							FiltreTexte filtreTexte = (FiltreTexte)reponseOuverte.getFiltre();
							
							String nomMethode = "getReponseouvertetexte_question_"+question.getPlace()+"_"+reponse.getCode();
							Method method = formulaire.getClass().getMethod(nomMethode,null);
							String formValeur = (String)method.invoke(formulaire,null);
							
							ValeurTexte valeur = new ValeurTexte();
							valeur.setValeur(formValeur);
							
							if(!filtreTexte.Check(valeur))
							{
								Object[] param = {question.getPlace(),reponse.getCode()};
								errors.rejectValue("reponseouvertetexte_question_"+question.getPlace()+"_"+reponse.getCode(),"instancequestionnaire.filtretexte.mauvais",param,null);
							}
						}
						//TODO else exception
					}
				}
			}	
			
		}
		
	}*/
}
